With the development in modern computer architecture, fast communication among multi-core processors makes parallel processing possible. Because large main memory configurations are available and affordable, server settings with hundreds of cores and terabytes of main memory become a reality.
High performance database systems, such as in-memory databases, are adaptive to make full usage of the main memory provided by modern hardware. In such systems, all relevant data may be kept in main memory, so that read operations can be executed without disk I/O. The systems may be designed to minimize the number of CPU cache misses and to avoid CPU stalls due to memory access. One approach for achieving this goal is using column-based storage in memory, which leads to high spatial locality of data and instructions, so the operations can be executed completely in the CPU cache without costly random memory accesses.
In a column-based storage, the entries of a column are stored in contiguous memory locations. Columnar data storage allows highly efficient compression, such that the relevant data can be stored in main memory with less cost using data compression. The data structure that contains the main part of the data is called the main storage. The changes are taken over from the delta storage asynchronously at some later point in time. The separation into main and delta storage allows high compression and high write performance at the same time. The column store may implement MVCC (Multi Version Concurrent Control), which is based on having multiple versions of the same data in the database. When reading data it ensures that the operation reads the right set of versions required to get a correct and consistent view of the database. A Consistent View Manager may determine which version of the database that each operation is allowed to see depending on the current transaction isolation level.
A requirement for a concurrency control mechanism is to minimize its impact on performance. With multi version concurrency control, concurrent read operations see a consistent view of the database without blocking concurrent write operations. However, conventional database management systems, such as OLAP (Online Analytical Processing) database systems, implement a table-level versioning mechanism. OLAP databases allows complex analytical and ad-hoc queries within a rapid execution time. In the table-level versioning mechanism of an OLAP system, multiple read-only and read-write users can operate concurrently, as long as the writers are inserting data into (or deleting it from) different tables. Such approach does not allow a high degree of concurrency with high performance throughput. As a result, many existing OLAP Relational Data Base Management Systems (RDBMS), do not have mechanisms such as a row-level snapshot isolation MVCC that allow concurrent transactions on the same table, and they are not OLTP friendly. Furthermore, conventional OLAP systems do not implement a mechanism for an existing store to be extended to offer row-level snapshot isolation and be optimized for OLTP workloads, with minimal changes to the existing code. Therefore, conventional systems fail to provide an ideal concurrent control mechanism with optimal performance and scalability.